ftp.cs.arizona.edu/ftp.cs.arizona.edu.tar/ftp.cs.arizona.edu/icon/newsgrp/group92c.txt/000045_icon-group-sender _Wed Oct 28 12:39:22 1992.msg

Internet Message Format | 1993-01-04 | 3KB

Received: by cheltenham.cs.arizona.edu; Fri, 30 Oct 1992 10:29:13 MST
Date: 28 Oct 92 12:39:22 GMT
From: mcsun!Germany.EU.net!sbsvax!coli-gate.coli.uni-sb.de!coli-gate.coli.uni-sb.de![e-mail]  (Stephen Spackman)
Organization: DFKI Saarbruecken GmbH, D-W 6600 Saarbruecken
Subject: Re: confusing errors
Message-Id: <[e-mail]>
References: <[e-mail]>
Sender: [e-mail]
To: [e-mail]
Status: R
Errors-To: [e-mail]

In article <[e-mail]> [e-mail] (Richard L. Goerwitz) writes:

|If you like regularity, just use LISP.  It is very easy to read and write
|automatically, and its syntax is trivial.  In fact, Icon is very easy to
|tokenize with automatic semicolon insertion, and I've never had any prob-
|lems reading or writing it.  Not as regular as LISP, but then LISP code
|is really not all that readable unless formatted with great skill (and a
|smart editor).  Syntactic regularity != usability.

But syntactic IRregularity != usability, either; in fact it definitely
degrades it. Just because one abysmal language (Lisp) has it but is
still terrible, doesn't mean that we should abandon it as a goal! In
fact, Lisp derives perhaps most of the few advantages it has from this
regularity, as language designers would do well to note. It's the
*particular choice* of regular syntax that is the problem.

Now a language like Icon just doesn't commit to any easily explainable
syntax - perhaps avoiding criticisms about its design, but only by the
smokescreen method! [note to the audience: goer and I know each other
reasonably well. Feel free to take this comment with a pinch of
rhetorical salt.]

|Maybe you are just baiting me, but the semicolon is not an operator with
|abstract semantics. It has semantics only in the sense that it directs the
|syntactic analyzer to map the concrete syntax to the abstract syntax in a
|certain way.

???? It's probably hopeless to direct you to the revised report on algol
68 [this isn't a random insult, if you've seen the document you'll know
exactly what I mean - it isn't exactly very readable], but if it doesn't
have semantics somewthing is BADLY wrong with this language. It doesn't
mean, "first do this, then do that"? Sounds like a pretty basic
operation to me, and NOT one I'd like left implicit, since it involves
the discarding of a result from its left argument, something that in
many programming styles is probably an error unless explicitly declared
otherwise.

Tell me, can you characterise for me the circumstances under which a
newline will NOT be interpreted as a go-on operator? When IS it safe to
break an expression?

And, really,  WHY would I ever want "throw away what I just did" to be
the DEFAULT operation?
------------------------------------------------------------------------
stephen p spackman                                       [e-mail]
------------------------------------------------------------------------